Usenet 1993 July/InfoMagic USENET CD-ROM July 1993.ISO/sources/unix/volume25/fsp/part03

Internet Message Format | 1991-12-13 | 38.1 KB

Subject: v25i026: A real-time, multithreaded Internet archive server, Part03/03
Newsgroups: comp.sources.unix
Approved: [e-mail]

Submitted-By: [e-mail]
Posting-Number: Volume 25, Issue 26
Archive-Name: fsp/part03

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 3 (of 3)."
# Contents:  bsd_src/ls.c bsd_src/random.c server_file.c
# Wrapped by [e-mail] on Fri Dec 13 17:53:12 1991
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'bsd_src/ls.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bsd_src/ls.c'\"
else
echo shar: Extracting \"'bsd_src/ls.c'\" \(10950 characters\)
sed "s/^X//" >'bsd_src/ls.c' <<'END_OF_FILE'
X/*
X * Copyright (c) 1989 The Regents of the University of California.
X * All rights reserved.
X *
X * This code is derived from software contributed to Berkeley by
X * Michael Fischbein.
X *
X * Redistribution and use in source and binary forms are permitted
X * provided that: (1) source distributions retain this entire copyright
X * notice and comment, and (2) distributions including binaries display
X * the following acknowledgement:  ``This product includes software
X * developed by the University of California, Berkeley and its contributors''
X * in the documentation or other materials provided with the distribution
X * and in all advertising materials mentioning features or use of this
X * software. Neither the name of the University nor the names of its
X * contributors may be used to endorse or promote products derived
X * from this software without specific prior written permission.
X * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
X * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
X * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
X */
X
X#ifndef lint
char copyright[] =
X"@(#) Copyright (c) 1989 The Regents of the University of California.\n\
X All rights reserved.\n";
X#endif /* not lint */
X
X#ifndef lint
static char sccsid[] = "@(#)ls.c    5.42 (Berkeley) 5/17/90";
X#endif /* not lint */
X
X#include "../client_def.h"
X#include <sys/ioctl.h>
X#include <string.h>
X#include "ls.h"
X#include "tweak.h"
X
int (*sortfcn)(), (*printfcn)();
char *emalloc();
X
int termwidth = 80;        /* default terminal width */
X
X/* flags */
int f_accesstime;        /* use time of last access */
int f_column;            /* columnated format */
int f_group;            /* show group ownership of a file */
int f_ignorelink;        /* indirect through symbolic link operands */
int f_inode;            /* print inode */
int f_kblocks;            /* print size in kilobytes */
int f_listalldot;        /* list . and .. as well */
int f_listdir;            /* list actual directory, not contents */
int f_listdot;            /* list files beginning with . */
int f_longform;            /* long listing format */
int f_needstat;            /* if need to stat files */
int f_newline;            /* if precede with newline */
int f_nonprint;            /* show unprintables as ? */
int f_nosort;            /* don't sort output */
int f_recursive;        /* ls subdirectories also */
int f_reversesort;        /* reverse whatever sort is used */
int f_singlecol;        /* use single column output */
int f_size;            /* list size in short listing */
int f_statustime;        /* use time of last mode change */
int f_dirname;            /* if precede with directory name */
int f_timesort;            /* sort by time vice name */
int f_total;            /* if precede with "total" line */
int f_type;            /* add type character for non-regular files */
X
fls_main(argc, argv)
X    int argc;
X    char **argv;
X{
X    extern int optind;
X    int ch;
X    char *p, *getenv();
X    int acccmp(), modcmp(), namecmp(), prcopy(), printcol();
X    int printlong(), printscol(), revacccmp(), revmodcmp(), revnamecmp();
X    int revstatcmp(), statcmp();
X
X    /* terminal defaults to -Cq, non-terminal defaults to -1 */
X    if (isatty(1)) {
X        f_nonprint = 1;
X        termwidth  = 80;
X#ifdef TIOCGWINSZ
X        {   struct winsize win;
X            if (ioctl(1, TIOCGWINSZ, &win) == -1 || !win.ws_col) {
X                if (p = getenv("COLUMNS"))
X                    termwidth = atoi(p);
X            }
X            else
X                termwidth = win.ws_col;
X        }
X#endif
X        f_column = 1;
X    } else
X        f_singlecol = 1;
X
X    /* root is -A automatically */
X    if (!getuid())
X        f_listdot = 1;
X
X    while ((ch = getopt(argc, argv, "1ACFLRacdfgiklqrstu")) != EOF) {
X        switch (ch) {
X        /*
X         * -1, -C and -l all override each other
X         * so shell aliasing works right
X         */
X        case '1':
X            f_singlecol = 1;
X            f_column = f_longform = 0;
X            break;
X        case 'C':
X            f_column = 1;
X            f_longform = f_singlecol = 0;
X            break;
X        case 'l':
X            f_longform = 1;
X            f_column = f_singlecol = 0;
X            break;
X        /* -c and -u override each other */
X        case 'c':
X            f_statustime = 1;
X            f_accesstime = 0;
X            break;
X        case 'u':
X            f_accesstime = 1;
X            f_statustime = 0;
X            break;
X        case 'F':
X            f_type = 1;
X            break;
X        case 'L':
X            f_ignorelink = 1;
X            break;
X        case 'R':
X            f_recursive = 1;
X            break;
X        case 'a':
X            f_listalldot = 1;
X            /* FALLTHROUGH */
X        case 'A':
X            f_listdot = 1;
X            break;
X        case 'd':
X            f_listdir = 1;
X            break;
X        case 'f':
X            f_nosort = 1;
X            break;
X        case 'g':
X            f_group = 1;
X            break;
X        case 'i':
X            f_inode = 1;
X            break;
X        case 'k':
X            f_kblocks = 1;
X            break;
X        case 'q':
X            f_nonprint = 1;
X            break;
X        case 'r':
X            f_reversesort = 1;
X            break;
X        case 's':
X            f_size = 1;
X            break;
X        case 't':
X            f_timesort = 1;
X            break;
X        default:
X        case '?':
X            usage();
X        }
X    }
X    argc -= optind;
X    argv += optind;
X
X    /* -d turns off -R */
X    if (f_listdir)
X        f_recursive = 0;
X
X    /* if need to stat files */
X    f_needstat = f_longform || f_recursive || f_timesort ||
X        f_size || f_type;
X
X    /* select a sort function */
X    if (f_reversesort) {
X        if (!f_timesort)
X            sortfcn = revnamecmp;
X        else if (f_accesstime)
X            sortfcn = revacccmp;
X        else if (f_statustime)
X            sortfcn = revstatcmp;
X        else /* use modification time */
X            sortfcn = revmodcmp;
X    } else {
X        if (!f_timesort)
X            sortfcn = namecmp;
X        else if (f_accesstime)
X            sortfcn = acccmp;
X        else if (f_statustime)
X            sortfcn = statcmp;
X        else /* use modification time */
X            sortfcn = modcmp;
X    }
X
X    /* select a print function */
X    if (f_singlecol)
X        printfcn = printscol;
X    else if (f_longform)
X        printfcn = printlong;
X    else
X        printfcn = printcol;
X
X    if (!argc) {
X        argc = 1;
X        argv[0] = ".";
X        argv[1] = NULL;
X    }
X    doargs(argc, argv);
X}
X
static char path[2*1024 + 1];
static char *endofpath = path;
X
doargs(argc, argv)
X    int argc;
X    char **argv;
X{
X    register LS *dstatp, *rstatp;
X    register int cnt, dircnt, dirmax, maxlen, regcnt, regmax;
X    LS *dstats, *rstats;
X    struct stat sb;
X    char top[2*1024 + 1], **av, *av2[2];
X    unsigned long blocks;
X    extern char **glob();
X
X    /*
X     * walk through the operands, building separate arrays of LS
X     * structures for directory and non-directory files.
X     */
X    dstats = rstats = NULL;
X    dirmax = regmax = 0;
X
X    for (dircnt = regcnt = 0; *argv; ++argv)
X    {
X        if(!(av = glob(*argv))) { av = av2; av2[0] = *argv; av2[1] = 0; }
X
X        for( ; *av; av++)
X        {
X        if (util_stat(*av, &sb)) {
X            perror(*av);
X            if (errno == ENOENT)
X                continue;
X            ls_bad(1);
X        }
X        if ((S_IFDIR & sb.st_mode) && !f_listdir) {
X            if(dirmax == dircnt)
X            {
X                dirmax += 10;
X                if (!dstats)
X                {
X                dstatp = dstats = (LS *)emalloc(dirmax *
X                                (sizeof(LS)));
X                } else
X                {
X                dstats = (LS *)realloc(dstats,
X                            dirmax * (sizeof(LS)));
X                dstatp = dstats + dircnt;
X                }
X            }
X            dstatp->name = *av;
X            dstatp->lstat = sb;
X            ++dstatp;
X            ++dircnt;
X        }
X        else {
X            if(regmax == regcnt)
X            {
X                regmax += 10;
X
X                if (!rstats)
X                {
X                blocks = 0;
X                maxlen = -1;
X                rstatp = rstats = (LS *)emalloc(regmax *
X                            (sizeof(LS)));
X                } else
X                {
X                rstats = (LS *)realloc(rstats,
X                            regmax * (sizeof(LS)));
X                rstatp = rstats + regcnt;
X                }
X            }
X            rstatp->name = *av;
X            rstatp->lstat = sb;
X
X            /* save name length for -C format */
X            rstatp->len = strlen(*av);
X
X            if (f_nonprint)
X                prcopy(*av, *av, rstatp->len);
X
X            /* calculate number of blocks if -l/-s formats */
X            if (f_longform || f_size)
X                blocks += (sb.st_size + 1023)/1024;
X
X            /* save max length if -C format */
X            if (f_column && maxlen < rstatp->len)
X                maxlen = rstatp->len;
X
X            ++rstatp;
X            ++regcnt;
X        }
X        }
X    }
X    /* display regular files */
X    if (regcnt) {
X        rstats[0].lstat.st_btotal = blocks;
X        rstats[0].lstat.st_maxlen = maxlen;
X        displaydir(rstats, regcnt);
X        f_newline = f_dirname = 1;
X    }
X    /* display directories */
X    if (dircnt) {
X        register char *p;
X
X        f_total = 1;
X        if (dircnt > 1) {
X            (void)util_getwd(top);
X            qsort((char *)dstats, dircnt, sizeof(LS), sortfcn);
X            f_dirname = 1;
X        }
X        for (cnt = 0; cnt < dircnt; ++dstats) {
X            for (endofpath = path, p = dstats->name;
X                *endofpath = *p++; ++endofpath);
X            subdir(dstats);
X            f_newline = 1;
X            if (++cnt < dircnt && util_cd(top)) {
X                perror(top);
X                ls_bad(1);
X            }
X        }
X    }
X}
X
displaydir(stats, num)
X    LS *stats;
X    register int num;
X{
X    register char *p, *savedpath;
X    LS *lp;
X
X    if (num > 1 && !f_nosort) {
X        unsigned long save1, save2;
X
X        save1 = stats[0].lstat.st_btotal;
X        save2 = stats[0].lstat.st_maxlen;
X        qsort((char *)stats, num, sizeof(LS), sortfcn);
X        stats[0].lstat.st_btotal = save1;
X        stats[0].lstat.st_maxlen = save2;
X    }
X
X    printfcn(stats, num);
X
X    if (f_recursive) {
X        savedpath = endofpath;
X        for (lp = stats; num--; ++lp) {
X            if (!(S_IFDIR & lp->lstat.st_mode))
X                continue;
X            p = lp->name;
X            if (p[0] == '.' && (!p[1] || p[1] == '.' && !p[2]))
X                continue;
X            if (endofpath != path && endofpath[-1] != '/')
X                *endofpath++ = '/';
X            for (; *endofpath = *p++; ++endofpath);
X            f_newline = f_dirname = f_total = 1;
X            subdir(lp);
X            *(endofpath = savedpath) = '\0';
X        }
X    }
X}
X
subdir(lp)
X    LS *lp;
X{
X    LS *stats;
X    int num;
X
X    if (f_newline)
X        (void)putchar('\n');
X    if (f_dirname)
X        (void)printf("%s:\n", path);
X
X    if (util_cd(lp->name)) {
X        perror(lp->name);
X        return;
X    }
X    if (num = tabdir(lp, &stats)) {
X        displaydir(stats, num);
X        (void)free((char *)stats);
X    }
X    if (util_cd("..")) {
X        perror("..");
X        ls_bad(1);
X    }
X}
X
tabdir(lp, s_stats)
X    LS *lp, **s_stats;
X{
X    register RDIR *dirp;
X    register int cnt, maxentry, maxlen;
X    register char *p;
X    struct rdirent *dp;
X    unsigned long blocks;
X    LS *stats;
X
X    if (!(dirp = util_opendir("."))) {
X        perror(lp->name);
X        return(0);
X    }
X    blocks = maxentry = maxlen = 0;
X    stats = NULL;
X    for (cnt = 0; dp = util_readdir(dirp);) {
X        /* this does -A and -a */
X        p = dp->d_name;
X        if (p[0] == '.') {
X            if (!f_listdot)
X                continue;
X            if (!f_listalldot && (!p[1] || p[1] == '.' && !p[2]))
X                continue;
X        }
X        if (cnt == maxentry) {
X#define    DEFNUM    256
X            maxentry += DEFNUM;
X            if(stats)
X            {
X              if (!(*s_stats = stats = (LS *)realloc((char *)stats,
X                (unsigned int)maxentry * sizeof(LS))))
X                nomem();
X            } else
X            {
X              if (!(*s_stats = stats = (LS *)malloc(
X                (unsigned int)maxentry * sizeof(LS))))
X                nomem();
X            }
X        }
X        if (f_needstat && util_stat(dp->d_name, &stats[cnt].lstat)) {
X            /*
X             * don't exit -- this could be an NFS mount that has
X             * gone away.  Flush stdout so the messages line up.
X             */
X            (void)fflush(stdout);
X            perror(dp->d_name);
X            continue;
X        }
X        stats[cnt].name = dp->d_name;
X
X        /*
X         * get the inode from the directory, so the -f flag
X         * works right.
X         */
X        stats[cnt].lstat.st_ino = dp->d_ino;
X
X        /* save name length for -C format */
X        stats[cnt].len = dp->d_namlen;
X
X        /* calculate number of blocks if -l/-s formats */
X        if (f_longform || f_size)
X            blocks += (stats[cnt].lstat.st_size + 1023)/1024;
X
X        /* save max length if -C format */
X        if (f_column && maxlen < (int)dp->d_namlen)
X            maxlen = dp->d_namlen;
X        ++cnt;
X    }
X    (void)util_closedir(dirp);
X
X    if (cnt) {
X        stats[0].lstat.st_btotal = blocks;
X        stats[0].lstat.st_maxlen = maxlen;
X    } else if (stats) {
X        (void)free((char *)stats);
X    }
X    return(cnt);
X}
END_OF_FILE
if test 10950 -ne `wc -c <'bsd_src/ls.c'`; then
    echo shar: \"'bsd_src/ls.c'\" unpacked with wrong size!
fi
# end of 'bsd_src/ls.c'
fi
if test -f 'bsd_src/random.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bsd_src/random.c'\"
else
echo shar: Extracting \"'bsd_src/random.c'\" \(12955 characters\)
sed "s/^X//" >'bsd_src/random.c' <<'END_OF_FILE'
X/*
X * Copyright (c) 1983 Regents of the University of California.
X * All rights reserved.
X *
X * Redistribution and use in source and binary forms are permitted
X * provided that: (1) source distributions retain this entire copyright
X * notice and comment, and (2) distributions including binaries display
X * the following acknowledgement:  ``This product includes software
X * developed by the University of California, Berkeley and its contributors''
X * in the documentation or other materials provided with the distribution
X * and in all advertising materials mentioning features or use of this
X * software. Neither the name of the University nor the names of its
X * contributors may be used to endorse or promote products derived
X * from this software without specific prior written permission.
X * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
X * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
X * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
X */
X
X#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)random.c    5.7 (Berkeley) 6/1/90";
X#endif /* LIBC_SCCS and not lint */
X
X#include <stdio.h>
X
X/*
X * random.c:
X * An improved random number generation package.  In addition to the standard
X * rand()/srand() like interface, this package also has a special state info
X * interface.  The initstate() routine is called with a seed, an array of
X * bytes, and a count of how many bytes are being passed in; this array is then
X * initialized to contain information for random number generation with that
X * much state information.  Good sizes for the amount of state information are
X * 32, 64, 128, and 256 bytes.  The state can be switched by calling the
X * setstate() routine with the same array as was initiallized with initstate().
X * By default, the package runs with 128 bytes of state information and
X * generates far better random numbers than a linear congruential generator.
X * If the amount of state information is less than 32 bytes, a simple linear
X * congruential R.N.G. is used.
X * Internally, the state information is treated as an array of longs; the
X * zeroeth element of the array is the type of R.N.G. being used (small
X * integer); the remainder of the array is the state information for the
X * R.N.G.  Thus, 32 bytes of state information will give 7 longs worth of
X * state information, which will allow a degree seven polynomial.  (Note: the
X * zeroeth word of state information also has some other information stored
X * in it -- see setstate() for details).
X * The random number generation technique is a linear feedback shift register
X * approach, employing trinomials (since there are fewer terms to sum up that
X * way).  In this approach, the least significant bit of all the numbers in
X * the state table will act as a linear feedback shift register, and will have
X * period 2^deg - 1 (where deg is the degree of the polynomial being used,
X * assuming that the polynomial is irreducible and primitive).  The higher
X * order bits will have longer periods, since their values are also influenced
X * by pseudo-random carries out of the lower bits.  The total period of the
X * generator is approximately deg*(2**deg - 1); thus doubling the amount of
X * state information has a vast influence on the period of the generator.
X * Note: the deg*(2**deg - 1) is an approximation only good for large deg,
X * when the period of the shift register is the dominant factor.  With deg
X * equal to seven, the period is actually much longer than the 7*(2**7 - 1)
X * predicted by this formula.
X */
X
X
X
X/*
X * For each of the currently supported random number generators, we have a
X * break value on the amount of state information (you need at least this
X * many bytes of state info to support this random number generator), a degree
X * for the polynomial (actually a trinomial) that the R.N.G. is based on, and
X * the separation between the two lower order coefficients of the trinomial.
X */
X
X#define        TYPE_0        0        /* linear congruential */
X#define        BREAK_0        8
X#define        DEG_0        0
X#define        SEP_0        0
X
X#define        TYPE_1        1        /* x**7 + x**3 + 1 */
X#define        BREAK_1        32
X#define        DEG_1        7
X#define        SEP_1        3
X
X#define        TYPE_2        2        /* x**15 + x + 1 */
X#define        BREAK_2        64
X#define        DEG_2        15
X#define        SEP_2        1
X
X#define        TYPE_3        3        /* x**31 + x**3 + 1 */
X#define        BREAK_3        128
X#define        DEG_3        31
X#define        SEP_3        3
X
X#define        TYPE_4        4        /* x**63 + x + 1 */
X#define        BREAK_4        256
X#define        DEG_4        63
X#define        SEP_4        1
X
X
X/*
X * Array versions of the above information to make code run faster -- relies
X * on fact that TYPE_i == i.
X */
X
X#define        MAX_TYPES    5        /* max number of types above */
X
static  int        degrees[ MAX_TYPES ]    = { DEG_0, DEG_1, DEG_2,
X                                DEG_3, DEG_4 };
X
static  int        seps[ MAX_TYPES ]    = { SEP_0, SEP_1, SEP_2,
X                                SEP_3, SEP_4 };
X
X
X
X/*
X * Initially, everything is set up as if from :
X *        initstate( 1, &randtbl, 128 );
X * Note that this initialization takes advantage of the fact that srandom()
X * advances the front and rear pointers 10*rand_deg times, and hence the
X * rear pointer which starts at 0 will also end up at zero; thus the zeroeth
X * element of the state information, which contains info about the current
X * position of the rear pointer is just
X *    MAX_TYPES*(rptr - state) + TYPE_3 == TYPE_3.
X */
X
static  long        randtbl[ DEG_3 + 1 ]    = { TYPE_3,
X                0x9a319039, 0x32d9c024, 0x9b663182, 0x5da1f342,
X                0xde3b81e0, 0xdf0a6fb5, 0xf103bc02, 0x48f340fb,
X                0x7449e56b, 0xbeb1dbb0, 0xab5c5918, 0x946554fd,
X                0x8c2e680f, 0xeb3d799f, 0xb11ee0b7, 0x2d436b86,
X                0xda672e2a, 0x1588ca88, 0xe369735d, 0x904f35f7,
X                0xd7158fd6, 0x6fa6f051, 0x616e6b96, 0xac94efdc,
X                0x36413f93, 0xc622c298, 0xf5a42ab8, 0x8a88d77b,
X                    0xf5ad9d0e, 0x8999220b, 0x27fb47b9 };
X
X/*
X * fptr and rptr are two pointers into the state info, a front and a rear
X * pointer.  These two pointers are always rand_sep places aparts, as they cycle
X * cyclically through the state information.  (Yes, this does mean we could get
X * away with just one pointer, but the code for random() is more efficient this
X * way).  The pointers are left positioned as they would be from the call
X *            initstate( 1, randtbl, 128 )
X * (The position of the rear pointer, rptr, is really 0 (as explained above
X * in the initialization of randtbl) because the state table pointer is set
X * to point to randtbl[1] (as explained below).
X */
X
static  long        *fptr            = &randtbl[ SEP_3 + 1 ];
static  long        *rptr            = &randtbl[ 1 ];
X
X
X
X/*
X * The following things are the pointer to the state information table,
X * the type of the current generator, the degree of the current polynomial
X * being used, and the separation between the two pointers.
X * Note that for efficiency of random(), we remember the first location of
X * the state information, not the zeroeth.  Hence it is valid to access
X * state[-1], which is used to store the type of the R.N.G.
X * Also, we remember the last location, since this is more efficient than
X * indexing every time to find the address of the last element to see if
X * the front and rear pointers have wrapped.
X */
X
static  long        *state            = &randtbl[ 1 ];
X
static  int        rand_type        = TYPE_3;
static  int        rand_deg        = DEG_3;
static  int        rand_sep        = SEP_3;
X
static  long        *end_ptr        = &randtbl[ DEG_3 + 1 ];
X
X
X
X/*
X * srandom:
X * Initialize the random number generator based on the given seed.  If the
X * type is the trivial no-state-information type, just remember the seed.
X * Otherwise, initializes state[] based on the given "seed" via a linear
X * congruential generator.  Then, the pointers are set to known locations
X * that are exactly rand_sep places apart.  Lastly, it cycles the state
X * information a given number of times to get rid of any initial dependencies
X * introduced by the L.C.R.N.G.
X * Note that the initialization of randtbl[] for default usage relies on
X * values produced by this routine.
X */
X
srandom( x )
X
X    unsigned        x;
X{
X        register  int        i, j;
X    long random();
X
X    if(  rand_type  ==  TYPE_0  )  {
X        state[ 0 ] = x;
X    }
X    else  {
X        j = 1;
X        state[ 0 ] = x;
X        for( i = 1; i < rand_deg; i++ )  {
X        state[i] = 1103515245*state[i - 1] + 12345;
X        }
X        fptr = &state[ rand_sep ];
X        rptr = &state[ 0 ];
X        for( i = 0; i < 10*rand_deg; i++ )  random();
X    }
X}
X
X
X
X/*
X * initstate:
X * Initialize the state information in the given array of n bytes for
X * future random number generation.  Based on the number of bytes we
X * are given, and the break values for the different R.N.G.'s, we choose
X * the best (largest) one we can and set things up for it.  srandom() is
X * then called to initialize the state information.
X * Note that on return from srandom(), we set state[-1] to be the type
X * multiplexed with the current value of the rear pointer; this is so
X * successive calls to initstate() won't lose this information and will
X * be able to restart with setstate().
X * Note: the first thing we do is save the current state, if any, just like
X * setstate() so that it doesn't matter when initstate is called.
X * Returns a pointer to the old state.
X */
X
char  *
initstate( seed, arg_state, n )
X
X    unsigned        seed;            /* seed for R. N. G. */
X    char        *arg_state;        /* pointer to state array */
X    int            n;            /* # bytes of state info */
X{
X    register  char        *ostate        = (char *)( &state[ -1 ] );
X
X    if(  rand_type  ==  TYPE_0  )  state[ -1 ] = rand_type;
X    else  state[ -1 ] = MAX_TYPES*(rptr - state) + rand_type;
X    if(  n  <  BREAK_1  )  {
X        if(  n  <  BREAK_0  )  {
X        fprintf( stderr, "initstate: not enough state (%d bytes); ignored.\n", n );
X        return 0;
X        }
X        rand_type = TYPE_0;
X        rand_deg = DEG_0;
X        rand_sep = SEP_0;
X    }
X    else  {
X        if(  n  <  BREAK_2  )  {
X        rand_type = TYPE_1;
X        rand_deg = DEG_1;
X        rand_sep = SEP_1;
X        }
X        else  {
X        if(  n  <  BREAK_3  )  {
X            rand_type = TYPE_2;
X            rand_deg = DEG_2;
X            rand_sep = SEP_2;
X        }
X        else  {
X            if(  n  <  BREAK_4  )  {
X            rand_type = TYPE_3;
X            rand_deg = DEG_3;
X            rand_sep = SEP_3;
X            }
X            else  {
X            rand_type = TYPE_4;
X            rand_deg = DEG_4;
X            rand_sep = SEP_4;
X            }
X        }
X        }
X    }
X    state = &(  ( (long *)arg_state )[1]  );    /* first location */
X    end_ptr = &state[ rand_deg ];    /* must set end_ptr before srandom */
X    srandom( seed );
X    if(  rand_type  ==  TYPE_0  )  state[ -1 ] = rand_type;
X    else  state[ -1 ] = MAX_TYPES*(rptr - state) + rand_type;
X    return( ostate );
X}
X
X
X
X/*
X * setstate:
X * Restore the state from the given state array.
X * Note: it is important that we also remember the locations of the pointers
X * in the current state information, and restore the locations of the pointers
X * from the old state information.  This is done by multiplexing the pointer
X * location into the zeroeth word of the state information.
X * Note that due to the order in which things are done, it is OK to call
X * setstate() with the same state as the current state.
X * Returns a pointer to the old state information.
X */
X
char  *
setstate( arg_state )
X
X    char        *arg_state;
X{
X    register  long        *new_state    = (long *)arg_state;
X    register  int        type        = new_state[0]%MAX_TYPES;
X    register  int        rear        = new_state[0]/MAX_TYPES;
X    char            *ostate        = (char *)( &state[ -1 ] );
X
X    if(  rand_type  ==  TYPE_0  )  state[ -1 ] = rand_type;
X    else  state[ -1 ] = MAX_TYPES*(rptr - state) + rand_type;
X    switch(  type  )  {
X        case  TYPE_0:
X        case  TYPE_1:
X        case  TYPE_2:
X        case  TYPE_3:
X        case  TYPE_4:
X        rand_type = type;
X        rand_deg = degrees[ type ];
X        rand_sep = seps[ type ];
X        break;
X
X        default:
X        fprintf( stderr, "setstate: state info has been munged; not changed.\n" );
X    }
X    state = &new_state[ 1 ];
X    if(  rand_type  !=  TYPE_0  )  {
X        rptr = &state[ rear ];
X        fptr = &state[ (rear + rand_sep)%rand_deg ];
X    }
X    end_ptr = &state[ rand_deg ];        /* set end_ptr too */
X    return( ostate );
X}
X
X
X
X/*
X * random:
X * If we are using the trivial TYPE_0 R.N.G., just do the old linear
X * congruential bit.  Otherwise, we do our fancy trinomial stuff, which is the
X * same in all ther other cases due to all the global variables that have been
X * set up.  The basic operation is to add the number at the rear pointer into
X * the one at the front pointer.  Then both pointers are advanced to the next
X * location cyclically in the table.  The value returned is the sum generated,
X * reduced to 31 bits by throwing away the "least random" low bit.
X * Note: the code takes advantage of the fact that both the front and
X * rear pointers can't wrap on the same call by not testing the rear
X * pointer if the front one has wrapped.
X * Returns a 31-bit random number.
X */
X
long
random()
X{
X    long        i;
X
X    if(  rand_type  ==  TYPE_0  )  {
X        i = state[0] = ( state[0]*1103515245 + 12345 )&0x7fffffff;
X    }
X    else  {
X        *fptr += *rptr;
X        i = (*fptr >> 1)&0x7fffffff;    /* chucking least random bit */
X        if(  ++fptr  >=  end_ptr  )  {
X        fptr = state;
X        ++rptr;
X        }
X        else  {
X        if(  ++rptr  >=  end_ptr  )  rptr = state;
X        }
X    }
X    return( i );
X}
X
END_OF_FILE
if test 12955 -ne `wc -c <'bsd_src/random.c'`; then
    echo shar: \"'bsd_src/random.c'\" unpacked with wrong size!
fi
# end of 'bsd_src/random.c'
fi
if test -f 'server_file.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'server_file.c'\"
else
echo shar: Extracting \"'server_file.c'\" \(11591 characters\)
sed "s/^X//" >'server_file.c' <<'END_OF_FILE'
X    /*********************************************************************\
X    *  Copyright (c) 1991 by Wen-King Su ([e-mail])   *
X    *                                                                     *
X    *  You may copy or modify this file in any manner you wish, provided  *
X    *  that this notice is always included, and that you hold the author  *
X    *  harmless for any loss or damage resulting from the installation or *
X    *  use of this software.                                              *
X    \*********************************************************************/
X
X#include "server_def.h"
X
X/*****************************************************************************
X* This file handles all file io in request to client requests.
X*****************************************************************************/
X
X#define NBSIZE (2*sizeof(UBUF))
X
extern *malloc();
X
X#define fexist(A) (!access(A,0))
X#define touch(A) close(open(A,O_CREAT,0777))
X
X/*****************************************************************************
X* Routine to check a path string given by the client.
X* Will replace null string by ".".
X* In case of error, returns the error string.
X*****************************************************************************/
X
char *check_path(path,len)
X    char *path;
X    int len;
X{
X    char *s;
X    int state;
X
X    if(len < 1) return("Path must have non-zero lenght");
X    if(len == 1 && path[0] == 0) { *path++ = '.'; *path = 0; return(NULLP); }
X    if(path[len-1]) return("Path not null terminated");
X
X    for(s = path, state = 0; *s; s++)
X    {
X    if(*s <= ' ' || *s >= '~') return("Path contains illegal chars");
X
X    switch(*s)
X    {
X        case '.': if(!state) return("Path can't begin with '.'");
X              break;
X
X        case '/': if(!state) return("Path can't contain '//'");
X              state = 0;
X              break;
X
X        default : state = 1;
X              break;
X    }
X    }
X
X    return(NULLP);
X}
X
X/*****************************************************************************
X* Put the directory name of path into dbuf.
X*****************************************************************************/
X
char *get_dir_name(path,dbuf)
X    char *path, *dbuf;
X{
X    char *p1,*p2,*p3;
X
X    for(p1 = path, p2 = p3 = dbuf; *p1; p1++, p3++)
X    {
X    if((*p3 = *p1) == '/') p2 = p3;
X    }
X
X    if(dbuf == p2) { dbuf[0] = '.'; dbuf[1] = 0; }
X          else { *p2 = 0;             }
X
X    return(dbuf);
X}
X
X/*****************************************************************************
X* Reads directory and write directory listing file.
X*****************************************************************************/
X
static build_dir_file(fp)
X    FILE *fp;
X{
X    int nlen, skip, rem;
X    DIR *dir_f;
X    struct dirent *dp;
X    struct stat    sb;
X    register char  *s;
X    RDIRENT rdb;
X    static char marker[] = "******************";
X
X    if(!(dir_f = opendir(".")))    /* assume I have cd to path already */
X    { fprintf(stderr,"Can't open dir during initialization\n"); exit(1); }
X
X    for(rem = UBUF_SPACE; dp = readdir(dir_f); )
X    {
X    if (dp->d_ino == 0) continue;
X    s = dp->d_name;
X                        /* hide dot files */
X    if((s[0] == '.') && ((s[1] !=  0 ) &&
X                 (s[1] != '.' || s[2] != 0))) continue;
X
X    if(stat(dp->d_name,&sb)) continue;
X
X    nlen = strlen(s)+1;
X
X    if(rem < RDHSIZE + nlen)
X    {
X        rdb.type = RDTYPE_SKIP;
X        if(rem <= RDHSIZE) { fwrite(marker,1,rem    ,fp); }
X              else { fwrite(marker,1,RDHSIZE,fp);
X                 fwrite(s, 1,rem-RDHSIZE,fp); }
X        rem = UBUF_SPACE;
X    }
X
X    rdb.type = ((S_IFDIR & sb.st_mode)) ? RDTYPE_DIR : RDTYPE_FILE;
X    rdb.size = htonl(sb.st_size);
X    rdb.time = htonl(sb.st_mtime);
X
X    fwrite(&rdb,1,RDHSIZE,fp);
X    fwrite(s,1,nlen,fp);
X    rem -= (nlen + RDHSIZE);
X
X    if((skip = (nlen + RDHSIZE) & 0x3))
X        { fwrite(&rdb,1,4-skip,fp); rem -= (4-skip); }
X
X    if(!rem) rem = UBUF_SPACE;
X    }
X
X    rdb.type = RDTYPE_END;
X    fwrite(&rdb,1,RDHSIZE,fp);
X
X    fflush(fp);
X    closedir(dir_f);
X}
X
X/***************************************************************************/
X
char *server_get_dir(path,fp)    /* assume path is validated */
X    char *path;            /* returned file may not point at BOF */
X    FILE **fp;
X{
X    struct stat sd, sf;
X    char   list_p[NBSIZE];
X
X    if(!*path) path = ".";
X    if(stat(path,&sd)) return("Can't find directory");
X    if(!(S_IFDIR & sd.st_mode)) return("Not a directory");
X
X    sprintf(list_p,"%s/.FSP_CONTENT",path);
X
X    if(!stat(list_p,&sf) && (sf.st_mtime >= sd.st_mtime))
X    {
X    *fp = fopen(list_p,"r");
X    if(!*fp) return("Can't read directory listing");
X    return((char *)0);
X    }
X
X    if(!(*fp = fopen(list_p,"w+"))) return("Can't create directory listing");
X    if(chdir(path)) return("Can't cd to directory");
X    build_dir_file(*fp);
X    if(chdir(home_dir) == -1) { perror("chdir2"); exit(1); }
X    return(NULLP);
X}
X
X/**********************************************************************/
X
char *server_del_file(path,inet_num)        /* assume path is validated */
X    char *path;
X    unsigned long inet_num;
X{
X    struct stat sb;
X    char   dir_p[NBSIZE], no_del_p[NBSIZE], owner_p[NBSIZE];
X
X    if(stat(path,&sb)) return("unlink: file not accessible");
X    if(!(S_IFREG & sb.st_mode)) return("unlink: not an ordinary file");
X
X    get_dir_name(path,dir_p);
X    sprintf(owner_p ,"%s/.OWN.%08X"  ,dir_p,inet_num);
X    sprintf(no_del_p,"%s/.FSP_NO_DEL",dir_p         );
X
X    if(!fexist(owner_p) && fexist(no_del_p))
X            return("no permission for removing this file");
X
X    if(unlink(path) == -1) return("unlink: cannot unlink");
X
X    return(NULLP);
X}
X
X/**********************************************************************/
X
char *server_del_dir(path,inet_num)        /* assume path is validated */
X    char *path;
X    unsigned long inet_num;
X{
X    struct stat sb;
X    char   dir_p[NBSIZE], no_del_p[NBSIZE], no_add_p[NBSIZE], owner_p[NBSIZE];
X    int    has_no_del_p, has_no_add_p;
X
X    if(stat(path,&sb)) return("rmdir: directory not accessible");
X    if(!(S_IFDIR & sb.st_mode)) return("rmdir: not an ordinary directory");
X
X    get_dir_name(path,dir_p);
X    sprintf( owner_p,"%s/.OWN.%08X"  ,dir_p,inet_num);
X    sprintf(no_del_p,"%s/.FSP_NO_DEL",dir_p         );
X
X    if(!fexist(owner_p) && fexist(no_del_p))
X            return("no permission for removing this directory");
X
X    sprintf( owner_p,"%s/.OWN.%08X"   ,path,inet_num);
X    sprintf(   dir_p,"%s/.FSP_CONTENT",path         );
X    sprintf(no_del_p,"%s/.FSP_NO_DEL" ,path                );
X    sprintf(no_add_p,"%s/.FSP_NO_ADD" ,path                );
X
X    if(!fexist(owner_p)) return("no permission for removing this directory");
X
X    unlink(owner_p); unlink(  dir_p);
X    has_no_del_p = !unlink(no_del_p);
X    has_no_add_p = !unlink(no_add_p);
X
X    if(rmdir(path) != 0)
X    {
X    if(has_no_del_p) touch(no_del_p);
X    if(has_no_add_p) touch(no_add_p);
X    if(     owner_p) touch( owner_p);
X    return("rmdir: cannot unlink");
X    }
X
X    return(NULLP);
X}
X
X/**********************************************************************/
X
char *server_make_dir(path,inet_num)        /* assume path is validated */
X    char *path;
X    unsigned long inet_num;
X{
X    char   dir_p[NBSIZE], no_del_p[NBSIZE], no_add_p[NBSIZE], owner_p[NBSIZE];
X
X    get_dir_name(path,dir_p);
X    sprintf( owner_p,"%s/.OWN.%08X"  ,dir_p,inet_num);
X    sprintf(no_add_p,"%s/.FSP_NO_ADD",dir_p         );
X
X    if(!fexist(owner_p) && fexist(no_add_p))
X            return("no permission for directory creation");
X
X    sprintf( owner_p,"%s/.OWN.%08X"   ,path,inet_num);
X    sprintf(   dir_p,"%s/.FSP_CONTENT",path         );
X    sprintf(no_del_p,"%s/.FSP_NO_DEL" ,path         );
X    sprintf(no_add_p,"%s/.FSP_NO_ADD" ,path         );
X
X    if(mkdir(path,0777) != 0) return("Can't create directory");
X
X    touch(no_del_p);
X    touch(no_add_p);
X    touch( owner_p);
X    return(NULLP);
X}
X
X/**********************************************************************/
X
char *server_get_file(path,fp)        /* assume path is validated */
X    char *path;
X    FILE **fp;
X{
X    struct stat sb;
X
X    if(stat(path,&sb)) return("Can't find file");
X    if(!(S_IFREG & sb.st_mode)) return("Not a file");
X    if(!(*fp = fopen(path,"r"))) return("Can't open file");
X    return(NULLP);
X}
X
X/**********************************************************************/
X
char *server_get_pro(s,inet_num)    /* s is both I and O */
X    char *s;
X    unsigned long inet_num;
X{
X    struct stat sb;
X    char   buf[NBSIZE];
X    char  *owner_s, *del_s, *add_s;
X
X    if(stat(s,&sb)) return("getpro: directory not accessible");
X    if(!(S_IFDIR & sb.st_mode)) return("getpro: not an ordinary directory");
X
X    sprintf(buf,"%s/.OWN.%08X",s,inet_num);
X    owner_s = (fexist(buf)) ? "your" : "some other";
X    sprintf(buf,"%s/.FSP_NO_DEL" ,s); del_s = (fexist(buf)) ? "NO" : "YES";
X    sprintf(buf,"%s/.FSP_NO_ADD" ,s); add_s = (fexist(buf)) ? "NO" : "YES";
X
X    sprintf(s,"(owner: %s machine)(delete: %s)(create: %s)",
X                        owner_s, del_s, add_s);
X    return(NULLP);
X}
X
X/**********************************************************************/
X
char *server_set_pro(path,key,inet_num)
X    char *path, *key;
X    unsigned long inet_num;
X{
X    struct stat sb;
X    char   buf[NBSIZE];
X
X    if(stat(path,&sb)) return("getpro: directory not accessible");
X    if(!(S_IFDIR & sb.st_mode)) return("getpro: not an ordinary directory");
X
X    sprintf(buf,"%s/.OWN.%08X",path,inet_num);
X    if(!fexist(buf)) return("no permission for changing the protection-mode");
X
X    switch(key[1])
X    {
X    case 'c': sprintf(buf,"%s/.FSP_NO_ADD",path); break;
X    case 'd': sprintf(buf,"%s/.FSP_NO_DEL",path); break;
X    default : return("bad flag");
X    }
X
X    switch(key[0])
X    {
X    case '-': touch(buf);  break;
X    case '+': unlink(buf); break;
X    default : return("bad flag");
X    }
X
X    return(NULLP);
X}
X
X/**********************************************************************
X*  These two are used for file uploading.
X**********************************************************************/
X
char *server_up_load(data,len,pos,inet_num)
X    char *data;
X    unsigned len;
X    unsigned long pos, inet_num;
X{
X    FILE *fp;
X    char  tname[NBSIZE];
X
X    sprintf(tname,".TMP.%08X",inet_num);
X
X    if(pos) {             fp = fopen(tname,"a"); }
X       else { unlink(tname); fp = fopen(tname,"w"); }
X
X    if(!fp) return("Cannot open temporary file");
X
X    fwrite(data, 1, len, fp);
X    fclose(fp);
X
X    return(NULLP);
X}
X
char *server_install(path,inet_num)
X    char *path;
X    unsigned long inet_num;
X{
X    FILE *ft, *fp;
X    char   tname[NBSIZE], no_add_p[NBSIZE], owner_p[NBSIZE], buf[512];
X    int bytes;
X
X    get_dir_name(path,tname);
X    sprintf( owner_p,"%s/.OWN.%08X"  ,tname,inet_num);
X    sprintf(no_add_p,"%s/.FSP_NO_ADD",tname         );
X    sprintf(tname,".TMP.%08X"        ,      inet_num);
X
X    if(!fexist(owner_p) && fexist(no_add_p))
X    {
X    unlink(tname);
X    return("no permission for writting to that file");
X    }
X
X    unlink(path);
X    if(link(tname,path) == 0) { unlink(tname); return(NULLP); }
X
X    if(!(ft = fopen(tname,"r"))) { unlink(tname);
X                   return("Can't open temporary file"); }
X
X    if(!(fp = fopen(path ,"w"))) { unlink(tname); fclose(ft);
X                   return("Can't open file for output"); }
X
X    while(bytes = fread(buf,1,sizeof(buf),ft)) fwrite(buf,1,bytes,fp);
X
X    fclose(ft); fclose(fp); unlink(tname); return(NULLP);
X}
X
X/**********************************************************************/
X
init_home_dir()
X{
X    if(*home_dir != '/') { fprintf(stderr,"[%s] does not start with a /\n");
X               exit(1); }
X
X    if(chdir(home_dir) == -1) { perror("chdir"); exit(1); }
X
X    if(dbug) { fprintf(stderr,"home on %s\n",home_dir); fflush(stderr); }
X}
X
X/***************************************************************************/
END_OF_FILE
if test 11591 -ne `wc -c <'server_file.c'`; then
    echo shar: \"'server_file.c'\" unpacked with wrong size!
fi
# end of 'server_file.c'
fi
echo shar: End of archive 3 \(of 3\).
cp /dev/null ark3isdone
MISSING=""
for I in 1 2 3 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 3 archives.
    rm -f ark[1-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0